package edu.erpan.bl.bean;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import javax.ejb.LocalBean;
import javax.ejb.Stateful;
import javax.persistence.Query;

import edu.erpan.bl.entities.LineaDetalleIngresoMp;
import edu.erpan.bl.entities.LineaDetalleIngresoMpPK;
import edu.erpan.bl.entities.MateriaPrima;
import edu.erpan.bl.entities.Opcion;
import edu.erpan.bl.entities.Proveedor;
import edu.erpan.bl.entities.RecepcionMateriaPrima;
import edu.erpan.util.entityManager.GenericEntityManager;
import edu.erpan.util.entityManager.exceptions.IdNotFoundException;
import edu.erpan.util.entityManager.exceptions.PersistException;
import edu.erpan.util.entityManager.exceptions.QueryException;

/**
 * Session Bean implementation class MateriaPrimaBean
 */
@Stateful
@LocalBean
public class MateriaPrimaBean extends GenericEntityManager<MateriaPrima> implements MateriaPrimaBeanRemote {
       
    /**
     * @see GenericEntityManager#GenericEntityManager(Class<E>)
     */
    public MateriaPrimaBean() {
        super(MateriaPrima.class);
        // TODO Auto-generated constructor stub
    }

	@Override
	public MateriaPrima consultarMateriaPrima(MateriaPrima entitie)
			throws QueryException, IdNotFoundException {
		// TODO Auto-generated method stub
		MateriaPrima materiaPrima=null;
		try{
			materiaPrima = findEntity(entitie);
		}catch (Exception e) {
			throw new QueryException(e);
		}
		return materiaPrima;
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<MateriaPrima> consultarMateriasPrimas() throws QueryException {
		String queryString= "SELECT materiaPrima FROM "+MateriaPrima.class.getName()+" materiaPrima ORDER BY materiaPrima.nombre ASC";
		Query query=getEntityManager().createQuery(queryString);
		List<MateriaPrima>materiasPrima=new ArrayList<MateriaPrima>(0);
		try{
			materiasPrima=query.getResultList();
		}catch (Exception e) {
			throw new QueryException(e);
		}
		return materiasPrima;
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<Opcion> consultarOpciones(String categoria)throws QueryException{
		String queryString= "SELECT opcion FROM "+Opcion.class.getName()+" opcion WHERE opcion.categoria= :categoria ORDER BY opcion.nombre ASC";
		Query query=getEntityManager().createQuery(queryString);
		query.setParameter("categoria", categoria);
		
		List<Opcion>tiposMasa=new ArrayList<Opcion>(0);
		try{
			tiposMasa=query.getResultList();
		}catch (Exception e) {
			throw new QueryException(e);
		}
		return tiposMasa;
	}
	
	@SuppressWarnings("unchecked")
	@Override
	public List<Proveedor> consultarProveedores(Boolean activo) throws QueryException{
		
		StringBuffer stringBuffer=new StringBuffer("SELECT proveedor FROM "+Proveedor.class.getName()+" proveedor ");
		
		if(activo!=null){
			stringBuffer.append("WHERE proveedor.activo = :activo ");
		}
		
		stringBuffer.append("ORDER BY proveedor.nombre ASC");
		
		String queryString=stringBuffer.toString();
		
		Query query=getEntityManager().createQuery(queryString);
		
		if(activo!=null){
			query.setParameter("activo", activo);
		}
		
		List<Proveedor>proveedores=new ArrayList<Proveedor>(0);
		try{
			proveedores=query.getResultList();
		}catch (Exception e) {
			throw new QueryException(e);
		}
		return proveedores;
		
	}

	@SuppressWarnings("unchecked")
	@Override
	public void guardarRecepcionMateriaPrima(
			RecepcionMateriaPrima recepcionMateriaPrima,
			List<LineaDetalleIngresoMp> listaLineasDetalleIngresoMp)
			throws PersistException {
		try{
			//this.getUserTransaction().begin();
			//this.getEntityManager().lock(recepcionMateriaPrima, LockModeType.OPTIMISTIC);
			
			this.getEntityManager().merge(recepcionMateriaPrima);
			
			String consultarUltimaRecepcion="SELECT recepcion FROM "+RecepcionMateriaPrima.class.getName()+" recepcion " +
					"ORDER BY recepcion.idrecepcionMateriaPrima DESC";
			Query query=this.getEntityManager().createQuery(consultarUltimaRecepcion);
			query.setMaxResults(1);
			
			List<RecepcionMateriaPrima>resultado=query.getResultList();
			if(!resultado.isEmpty()){
				recepcionMateriaPrima=resultado.get(0);
			}
			
			for(LineaDetalleIngresoMp detalleIngresoMp:listaLineasDetalleIngresoMp){
				LineaDetalleIngresoMpPK id=new LineaDetalleIngresoMpPK();
				id.setIdRecepcionMateria(recepcionMateriaPrima.getIdrecepcionMateriaPrima());
				id.setMateriaPrimaIdmateriaPrima(detalleIngresoMp.getMateriaPrima().getIdmateriaPrima());
				
				detalleIngresoMp.setId(id);
				
				MateriaPrima materiaPrima=detalleIngresoMp.getMateriaPrima();
				BigDecimal inventario=materiaPrima.getInventario();
				if(inventario==null){
					inventario=BigDecimal.ZERO;
				}
				
				inventario=inventario.add(materiaPrima.getPeso().multiply(new BigDecimal(detalleIngresoMp.getCantidad())));
				materiaPrima.setInventario(inventario);
				
				this.getEntityManager().merge(materiaPrima);
				this.getEntityManager().merge(detalleIngresoMp);
			}
			
			//this.getUserTransaction().commit();
		}catch (Exception e) {
			/*try {
				this.getUserTransaction().rollback();
			} catch (IllegalStateException e1) {
				throw new PersistException(e1);
			} catch (SecurityException e1) {
				throw new PersistException(e1);
			} catch (SystemException e1) {
				throw new PersistException(e1);
			}*/
			throw new PersistException(e);
		}/*finally{
			if(this.getEntityManager()!=null){
				this.getEntityManager().close();
			}
		}*/
	}

	@Override
	public void editarRecepcionMateriaPrima(
			RecepcionMateriaPrima recepcionMateriaPrima)
			throws PersistException {
		try{
			this.getEntityManager().merge(recepcionMateriaPrima);
		}catch (Exception e) {
			throw new PersistException(e);
		}		
	}

	@SuppressWarnings("unchecked")
	@Override
	public void eliminarRecepcionMateriaPrima(
			RecepcionMateriaPrima recepcionMateriaPrima) throws QueryException {
		try{
			//this.getUserTransaction().begin();
			
			StringBuffer stringQuery=new StringBuffer("SELECT lineaDetalle FROM "+LineaDetalleIngresoMp.class.getName()+" AS lineaDetalle ");
			stringQuery.append("INNER JOIN lineaDetalle.recepcionMateriaPrima rmp ");
			stringQuery.append("WHERE rmp.idrecepcionMateriaPrima = :idRecepcionMP ");
			
			Query query=this.getEntityManager().createQuery(stringQuery.toString());
			query.setParameter("idRecepcionMP", recepcionMateriaPrima.getIdrecepcionMateriaPrima());
			
			List<LineaDetalleIngresoMp>listaLineaDetalle=query.getResultList();
			
			for(LineaDetalleIngresoMp detalleIngresoMp:listaLineaDetalle){
				detalleIngresoMp=this.getEntityManager().getReference(LineaDetalleIngresoMp.class, detalleIngresoMp.getId());
				this.getEntityManager().remove(detalleIngresoMp);
			}

			recepcionMateriaPrima=this.getEntityManager().getReference(RecepcionMateriaPrima.class, recepcionMateriaPrima.getIdrecepcionMateriaPrima());
			this.getEntityManager().remove(recepcionMateriaPrima);
			
			//this.getUserTransaction().commit();
		}catch (Exception e) {
			/*try {
				this.getUserTransaction().rollback();
			} catch (IllegalStateException e1) {
				throw new QueryException(e1);
			} catch (SecurityException e1) {
				throw new QueryException(e1);
			} catch (SystemException e1) {
				throw new QueryException(e1);
			}*/
			throw new QueryException(e);
		}/*finally{
			if(this.getEntityManager()!=null){
				this.getEntityManager().close();
			}
		}*/	
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<RecepcionMateriaPrima> consultarRecepcionesMateriaPrima()
			throws QueryException {
		StringBuffer stringQuery=new StringBuffer("SELECT rmp FROM "+RecepcionMateriaPrima.class.getName()+" AS rmp ");
		List<RecepcionMateriaPrima>listaRecepcionMateriaPrimas =new ArrayList<RecepcionMateriaPrima>(0);
		try{
			Query query=this.getEntityManager().createQuery(stringQuery.toString());
			listaRecepcionMateriaPrimas=query.getResultList();
		}catch (Exception e) {
			throw new QueryException(e);
		}
		
		return listaRecepcionMateriaPrimas;
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<LineaDetalleIngresoMp> consultarLineasDetalleRecepcion(
			RecepcionMateriaPrima recepcionMateriaPrima) throws QueryException {
		StringBuffer stringQuery=new StringBuffer("SELECT lineaDetalle FROM "+LineaDetalleIngresoMp.class.getName()+" AS lineaDetalle ");
		stringQuery.append("INNER JOIN lineaDetalle.recepcionMateriaPrima rmp ");
		stringQuery.append("WHERE rmp.idrecepcionMateriaPrima = :idRecepcionMP ");
		List<LineaDetalleIngresoMp>listaLineaDetalle =new ArrayList<LineaDetalleIngresoMp>(0);
		try{
			Query query=this.getEntityManager().createQuery(stringQuery.toString());
			query.setParameter("idRecepcionMP", recepcionMateriaPrima.getIdrecepcionMateriaPrima());
			listaLineaDetalle=query.getResultList();
		}catch (Exception e) {
			throw new QueryException(e);
		}
		return listaLineaDetalle;
	}

	@Override
	public RecepcionMateriaPrima consultarRecepcionMateriaPrima(
			RecepcionMateriaPrima recepcionMateriaPrima) throws QueryException {
		StringBuffer stringBuffer=new StringBuffer("SELECT recepcion FROM "+RecepcionMateriaPrima.class.getName()+" recepcion ");
		
		stringBuffer.append("WHERE recepcion.idrecepcionMateriaPrima = :idRecepcion ");
		
		String queryString=stringBuffer.toString();
		
		Query query=getEntityManager().createQuery(queryString);
		
		query.setParameter("idRecepcion", recepcionMateriaPrima.getIdrecepcionMateriaPrima());
		
		RecepcionMateriaPrima recepcionMP=null;
		try{
			recepcionMP=(RecepcionMateriaPrima) query.getSingleResult();
		}catch (Exception e) {
			throw new QueryException(e);
		}
		return recepcionMP;
	}

	@Override
	public void guardarProveedor(Proveedor proveedor) throws PersistException {
		try{
			this.getEntityManager().merge(proveedor);
		}catch (Exception e) {
			throw new PersistException(e);
		}
	}

	@Override
	public void editarProveedor(Proveedor proveedor) throws PersistException {
		try{
			this.getEntityManager().merge(proveedor);
		}catch (Exception e) {
			throw new PersistException(e);
		}
	}

	@Override
	public Proveedor consultarProveedor(Proveedor proveedor)
			throws QueryException, IdNotFoundException {
		StringBuffer stringBuffer=new StringBuffer("SELECT proveedor FROM "+Proveedor.class.getName()+" proveedor ");
		
		stringBuffer.append("WHERE proveedor.idproveedores = :idProveedor ");
		
		String queryString=stringBuffer.toString();
		
		Query query=getEntityManager().createQuery(queryString);
		
		query.setParameter("idProveedor", proveedor.getIdproveedores());
		
		Proveedor proveedorRS=null;
		try{
			proveedorRS=(Proveedor) query.getSingleResult();
		}catch (Exception e) {
			throw new QueryException(e);
		}
		return proveedorRS;
	}
}
